/*********************
* 树结构窗体,获取数结构节点属性的key值统一都为小写
* xuqiang
* 2016-12-25
***********************/
Ext.namespace("Ext.com.bkfm");
Ext.define('Ext.com.bkfm.tree', {
	extend: "Ext.tree.Panel",
	rootTreeId: '-1',//tree数据节点的根目录序号，用于获取根数据，默认-1
	rootLabel: '根目录',//根节点显示名称
	treeConfigId: "",//tree配置id
	filter: "",//查询条件,不需要加where关键字，只需要直接后街and即可 排序也使用该方式
	mappingField: '',//自定义映射字段
	objPath: '',//建模路径
	checkbox: false,//是否显示checkbox默认不显示
	dataSource: 'server',//默认数据来源为服务端,server:服务端,local:本地
	initComponent: function(){
		if(this.dataSource == 'server'){
			//远程服务端请求
			if(Ext.isEmpty(this.treeConfigId)){
				AjaxUtils.showError('无效的“treeConfigId”参数');
			}else{
				this.createTreePanel();
			}
		}
		this.callParent(arguments);
	},
	createTreePanel: function(){
		var tree = this;
		//设置treepanel的字段映射model
		var modelname = this.treeConfigId+"_TreeModel";
		var treeFields = [{name : "id",type : "string"},
		                {name : "text",type : "string"},
		                {name : "iconCls",type : "string"},
		                {name : "leaf",type : "boolean"}];
		if(this.checkbox){
			//显示checkbox
			treeFields.push({name : "checked",type:"boolean"});
		}
		if(Ext.isArray(this.mappingField)){
			for(i in this.mappingField){
				var mapping = {
						name: Ext.util.Format.lowercase(this.mappingField[i])
				};
				treeFields.push(mapping);
			}
		}
		var model = Ext.define(modelname, { // 定义树节点数据模型
            extend : "Ext.data.Model",
            fields : treeFields
        });

	    var store = Ext.create('Ext.data.TreeStore', {
	    	model : model,//定义当前store对象的Model数据模型
	        proxy : {
	                type : 'ajax',
	                url : CONTEXT.contextPath+ "/bkfm/metadata/v1/gettree",
	                actionMethods : "POST",
	                reader : {
	                    type : 'json',
	                    root : 'list'//数据
	                },
	                //传参
	                extraParams : {
	                	treeConfigId: tree.treeConfigId,
	                	filter: tree.filter
	                }
	            },
	        root : {
	            text : tree.rootLabel,
	            id: tree.rootTreeId || '-1',
	            expanded : true
	        },
	        listeners : {
	            'beforeexpand' : function(store,node,eOpts){
	            	//点击父亲节点的菜单会将节点的id通过ajax请求，将到后台
	            	//debugger;
	                //this.proxy.extraParams.parentId = node.raw.pid || tree.rootTreeId;
	                //alert(store.get("id"));
	            	//设置摘开节点的id
	            	tree.setSelectNodeId(store.get("id"));

	            },
	            'beforeload': function(store,operation,eOpts){
	            	//debugger;
	            	this.proxy.extraParams.parentId = operation.id|| self.rootTreeId;
	            }
	        }
	    });
	    this.store = store;
	    
	    if(this.checkbox){
			//显示checkbox
			this.on("checkchange", function(node, checked, eOpts){
				//tree.travelParentChecked(node, checked, eOpts);//默认选中父节点
				tree.travelChildrenChecked(node, checked, eOpts);//默认同步选中子节点
			});
		}
	},
	//递归遍历父节点
	travelParentChecked: function(node, checkStatus, opts){
		var tree = this;
		//父节点
		var upNode = node.parentNode;
		if(upNode != null){
			var opts = {};
			opts["isPassive"] = true;
			//父节点当前选中状态
			var upChecked = upNode.data.checked;
			
			//选中状态，遍历父节点，判断有父节点下的子节点是否都全选
			if(checkStatus){
				var allChecked = true;
				//此时父节点不可能是选中状态
				//如果有一个节点未选中，可以判断，当前父节点肯定是未选中状态，所以此时不必向上遍历
				upNode.eachChild(function (child) {
					if(!child.data.checked){
						allChecked = false;
						
						return false;
					}
				});
				
				upNode.set('checked', allChecked);
				if(allChecked){
					tree.travelParentChecked(upNode, allChecked, opts);
				}else{//如果后台传递数据时，选择状态正确的话，此处不需要执行
					//travelParentChecked(upNode, allChecked, opts);
				}
			}else{//未选中，让父节点全都 不选
				if(upNode.data.checked){
					upNode.set('checked', checkStatus);
					tree.travelParentChecked(upNode, checkStatus, opts);
				}else{
					//travelParentChecked(upNode, allChecked, opts);
				}
			}
		}
	},
	//归遍历子节点，复选框
	travelChildrenChecked: function(node, checkStatus, eOpts){
		var tree = this;
		var isLeaf = node.data.leaf;
		if(!isLeaf){
			node.expand(false, function(){
				//if(eOpts["isPassive"] == null){//主动点击
					node.eachChild(function (child) {
						child.set('checked', checkStatus);
						
						tree.travelChildrenChecked(child, checkStatus, eOpts);
						//child.fireEvent('checkchange',child, checked);//不知什么原因，不起作用
					});
				//}
			});
		}
		node.set('checked', checkStatus);

	},
	//设置选中节点的id值
	setSelectNodeId: function(id){
		this.selectNodeId = id;
	},
	//获取选中或者展开节点的id
	getSelectNodeId: function(){
		return this.selectNodeId;
	},
	//根据id查询节点
	getSelectNodeById: function(id){
		return this.store.getNodeById(id);
	},
	//获取选中节点
	getSelectNode: function(){
		var node = this.getSelectionModel().selected;
		//debugger;
		if(node && node.items && node.items.length >0){
			return node.items[0];
		}else{
			if(!Ext.isEmpty(this.getSelectNodeId())){
				return this.store.getNodeById(this.getSelectNodeId());
			}
		}

		//返回根目录节点，
		return this.getRootNode();
	},
	/**
	 * 获取选中节点的父节点,不存在则返回根节点
	 */
	getSelectParentNode: function(){
		return this.getSelectNode().parentNode || this.getRootNode()
	},
	listeners:{
		itemclick:{
			fn: function(obj, record, item,index, e, eOpts ){
				//设置选中的值
				this.setSelectNodeId(record.get("id"));
			}
		}
	},
	/**
	 * 刷新节点，refreshNode 节点存在则直接刷新传入节点，否则刷新当前选中的节点
	 * selNode 刷新成功后需要选择的节点
	 */
	reloadSelectNode: function(refreshNode){
		var node = refreshNode || this.getSelectNode();
		if(node.isExpanded()){
			node.store.load({
				node: node
			});
		}else{
			node.expand();
		}

	},
	/**
	 * 删除选中节点，或者删除传入的节点
	 */
	delSelectNode: function(selNode,callback){
		if(!selNode){
			AjaxUtils.showError("请选择需要删除的节点");
			return;
		}

		if(!selNode.isLeaf()){
			AjaxUtils.showError("当前节点存在子节点，不可删除");
			return;
		}
		if(Ext.isEmpty(this.objPath)){
			AjaxUtils.showError("业务建模路径为配置，不可删除");
			return;
		}
		var tree = this;
		
		var del_param = new Array();
			del_param.push({
				"obj_path": tree.objPath,
				"rwid": selNode.get("id")
			});

		//判断是否需要远程删除
		if(Ext.isEmpty(del_param)){
			return;
		}
		
		AjaxUtils.showConfirm(function(){
			AjaxUtils.CallService({
				url: CONTEXT.contextPath+"/bkfm/metadata/v1/delmodelmetadata",
				dataType: "json",
				params: del_param,
				call: function(data){
					if(data.status=='OK'){
						AjaxUtils.showInfo('操作成功',function(){
							var node  = tree.getSelectNode();
							var parentNode = node;

							//判断当前选择的节点是否为根节点
							if(node.get("id") != tree.rootTreeId){
								//不是根节点则获取父节点刷新
								parentNode = node.parentNode;
							}
							if(Ext.isFunction(callback)){
								Ext.callback(callback, this, data);
							}
							tree.reloadSelectNode(parentNode);
						});

					}else{
						AjaxUtils.showError('操作失败',function(){
							if(Ext.isFunction(callback)){
								Ext.callback(callback, this, data);
							}
						});
					}
				}
			});
		},"确定需要删除所选节点？删除后将不可恢复!");
	},
    filterByText: function(text) {  
        this.filterBy(text, 'text');  
    },  
    /** 
     * 根据字符串过滤所有的节点，将不符合条件的节点进行隐藏. 
     * @param 查询字符串. 
     * @param 要查询的列. 
     */  
    filterBy: function(text, by) {  
    	var selfTree = this;
        this.clearFilter();  
  
        var view = this.getView(),  
            me = this,  
            nodesAndParents = [];  
  
        // 找到匹配的节点并展开.  
        // 添加匹配的节点和他们的父节点到nodesAndParents数组.  
        this.getRootNode().cascadeBy(function(tree, view) {  
            var currNode = this;  
  
            if (currNode && currNode.data[by] && currNode.data[by].toString().toLowerCase().indexOf(text.toLowerCase()) > -1) {  
                me.expandPath(currNode.getPath());  
  
                while (currNode.parentNode) {  
                    nodesAndParents.push(currNode.id);  
                    currNode = currNode.parentNode;  
                }  
            }  
        }, null, [me, view]);  
  
        // 将不在nodesAndParents数组中的节点隐藏  
        this.getRootNode().cascadeBy(function(tree, view) {  
            var uiNode = view.getNodeByRecord(this);  
  
            if (uiNode && !Ext.Array.contains(nodesAndParents, this.id)) { 
            	//不隐藏根节点信息
            	if(!this.id.endsWith(selfTree.rootTreeId)){
            		Ext.get(uiNode).setDisplayed('none');  
            	}
                
            }  
        }, null, [me, view]);  
    },  
    clearFilter: function() {  
        var view = this.getView();  
        this.getRootNode().cascadeBy(function(tree, view) {  
            var uiNode = view.getNodeByRecord(this);  
  
            if (uiNode) {  
                Ext.get(uiNode).setDisplayed('table-row');  
            }  
        }, null, [this, view]);  
    }
});